
extern "C" {
    pub type event_base;
    pub type evbuffer;
    pub type bufferevent_ops;
    pub type args;
    pub type tmuxpeer;
    pub type hyperlinks;
    pub type screen_write_cline;
    pub type screen_sel;
    pub type screen_titles;
    pub type environ;
    pub type options;
    pub type format_tree;
    pub type input_ctx;
    pub type cmds;
    pub type tty_key;
    pub type tty_code;
    pub type format_job_tree;
    pub type control_state;
    pub type cmdq_list;
    pub type cmdq_item;
    fn fnmatch(__pattern: *const i8, __name: *const i8, __flags: i32) -> i32;
    fn free(_: *mut ());
    fn memset(_: *mut (), _: i32, _: u64) -> *mut ();
    fn strcmp(_: *const i8, _: *const i8) -> i32;
    fn strncmp(_: *const i8, _: *const i8, _: u64) -> i32;
    fn strchr(_: *const i8, _: i32) -> *mut i8;
    fn strlen(_: *const i8) -> u64;
    fn strtonum(_: *const i8, _: i64, _: i64, _: *mut *const i8) -> i64;
    fn strlcat(_: *mut i8, _: *const i8, _: size_t) -> size_t;
    fn xreallocarray(_: *mut (), _: size_t, _: size_t) -> *mut ();
    fn xstrdup(_: *const i8) -> *mut i8;
    fn environ_find(_: *mut environ, _: *const i8) -> *mut environ_entry;
    fn cmdq_error(_: *mut cmdq_item, _: *const i8, _: ...);
    static mut clients: clients;
    fn cmdq_get_client(_: *mut cmdq_item) -> *mut client;
    static mut marked_pane: cmd_find_state;
    fn server_check_marked() -> i32;
    fn cmd_mouse_window(_: *mut mouse_event, _: *mut *mut session) -> *mut winlink;
    fn cmd_mouse_pane(
        _: *mut mouse_event,
        _: *mut *mut session,
        _: *mut *mut winlink,
    ) -> *mut window_pane;
    fn cmdq_get_event(_: *mut cmdq_item) -> *mut key_event;
    fn cmdq_get_current(_: *mut cmdq_item) -> *mut cmd_find_state;
    fn server_client_get_pane(_: *mut client) -> *mut window_pane;
    fn winlink_find_by_index(_: *mut winlinks, _: i32) -> *mut winlink;
    fn window_pane_tree_RB_MINMAX(_: *mut window_pane_tree, _: i32) -> *mut window_pane;
    static mut all_window_panes: window_pane_tree;
    fn window_pane_tree_RB_NEXT(_: *mut window_pane) -> *mut window_pane;
    fn winlinks_RB_MINMAX(_: *mut winlinks, _: i32) -> *mut winlink;
    fn winlinks_RB_NEXT(_: *mut winlink) -> *mut winlink;
    fn window_pane_find_by_id_str(_: *const i8) -> *mut window_pane;
    fn winlink_previous_by_number(_: *mut winlink, _: *mut session, _: i32) -> *mut winlink;
    fn winlink_next_by_number(_: *mut winlink, _: *mut session, _: i32) -> *mut winlink;
    fn window_find_by_id_str(_: *const i8) -> *mut window;
    fn window_find_string(_: *mut window, _: *const i8) -> *mut window_pane;
    fn window_pane_at_index(_: *mut window, _: u_int) -> *mut window_pane;
    fn window_pane_previous_by_number(
        _: *mut window,
        _: *mut window_pane,
        _: u_int,
    ) -> *mut window_pane;
    fn window_pane_next_by_number(
        _: *mut window,
        _: *mut window_pane,
        _: u_int,
    ) -> *mut window_pane;
    fn window_pane_find_right(_: *mut window_pane) -> *mut window_pane;
    fn window_pane_find_left(_: *mut window_pane) -> *mut window_pane;
    fn window_pane_find_down(_: *mut window_pane) -> *mut window_pane;
    fn window_pane_find_up(_: *mut window_pane) -> *mut window_pane;
    fn window_has_pane(_: *mut window, _: *mut window_pane) -> i32;
    fn sessions_RB_NEXT(_: *mut session) -> *mut session;
    static mut sessions: sessions;
    fn sessions_RB_MINMAX(_: *mut sessions, _: i32) -> *mut session;
    fn session_alive(_: *mut session) -> i32;
    fn session_find_by_id_str(_: *const i8) -> *mut session;
    fn session_find(_: *const i8) -> *mut session;
    fn session_has(_: *mut session, _: *mut window) -> i32;
    fn log_debug(_: *const i8, _: ...);
    fn fatalx(_: *const i8, _: ...) -> !;
}
pub type __u_char = u8;
pub type __u_short = u16;
pub type __u_int = u32;
pub type __uint8_t = u8;
pub type __uint64_t = u64;
pub type __pid_t = i32;
pub type __time_t = i64;
pub type __suseconds_t = i64;
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type pid_t = __pid_t;
pub type time_t = __time_t;
pub type size_t = u64;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
pub type cc_t = u8;
pub type speed_t = u32;
pub type tcflag_t = u32;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct termios {
    pub c_iflag: tcflag_t,
    pub c_oflag: tcflag_t,
    pub c_cflag: tcflag_t,
    pub c_lflag: tcflag_t,
    pub c_line: cc_t,
    pub c_cc: [cc_t; 32],
    pub c_ispeed: speed_t,
    pub c_ospeed: speed_t,
}
pub type uint8_t = __uint8_t;
pub type uint64_t = __uint64_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event {
    pub ev_evcallback: event_callback,
    pub ev_timeout_pos: C2RustUnnamed_4,
    pub ev_fd: i32,
    pub ev_base: *mut event_base,
    pub ev_: C2RustUnnamed,
    pub ev_events: i16,
    pub ev_res: i16,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed {
    pub ev_io: C2RustUnnamed_2,
    pub ev_signal: C2RustUnnamed_0,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_0 {
    pub ev_signal_next: C2RustUnnamed_1,
    pub ev_ncalls: i16,
    pub ev_pncalls: *mut i16,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
    pub ev_io_next: C2RustUnnamed_3,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_3 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_4 {
    pub ev_next_with_common_timeout: C2RustUnnamed_5,
    pub min_heap_idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_5 {
    pub tqe_next: *mut event,
    pub tqe_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_callback {
    pub evcb_active_next: C2RustUnnamed_7,
    pub evcb_flags: i16,
    pub evcb_pri: uint8_t,
    pub evcb_closure: uint8_t,
    pub evcb_cb_union: C2RustUnnamed_6,
    pub evcb_arg: *mut (),
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_6 {
    pub evcb_callback: Option<unsafe extern "C" fn(i32, i16, *mut ()) -> ()>,
    pub evcb_selfcb: Option<unsafe extern "C" fn(*mut event_callback, *mut ()) -> ()>,
    pub evcb_evfinalize: Option<unsafe extern "C" fn(*mut event, *mut ()) -> ()>,
    pub evcb_cbfinalize: Option<unsafe extern "C" fn(*mut event_callback, *mut ()) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_7 {
    pub tqe_next: *mut event_callback,
    pub tqe_prev: *mut *mut event_callback,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct bufferevent {
    pub ev_base: *mut event_base,
    pub be_ops: *const bufferevent_ops,
    pub ev_read: event,
    pub ev_write: event,
    pub input: *mut evbuffer,
    pub output: *mut evbuffer,
    pub wm_read: event_watermark,
    pub wm_write: event_watermark,
    pub readcb: bufferevent_data_cb,
    pub writecb: bufferevent_data_cb,
    pub errorcb: bufferevent_event_cb,
    pub cbarg: *mut (),
    pub timeout_read: timeval,
    pub timeout_write: timeval,
    pub enabled: i16,
}
pub type bufferevent_event_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, i16, *mut ()) -> ()>;
pub type bufferevent_data_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, *mut ()) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_watermark {
    pub low: size_t,
    pub high: size_t,
}
pub type bitstr_t = u8;
pub type msgtype = u32;
pub const MSG_READ_CANCEL: msgtype = 307;
pub const MSG_WRITE_CLOSE: msgtype = 306;
pub const MSG_WRITE_READY: msgtype = 305;
pub const MSG_WRITE: msgtype = 304;
pub const MSG_WRITE_OPEN: msgtype = 303;
pub const MSG_READ_DONE: msgtype = 302;
pub const MSG_READ: msgtype = 301;
pub const MSG_READ_OPEN: msgtype = 300;
pub const MSG_FLAGS: msgtype = 218;
pub const MSG_EXEC: msgtype = 217;
pub const MSG_WAKEUP: msgtype = 216;
pub const MSG_UNLOCK: msgtype = 215;
pub const MSG_SUSPEND: msgtype = 214;
pub const MSG_OLDSTDOUT: msgtype = 213;
pub const MSG_OLDSTDIN: msgtype = 212;
pub const MSG_OLDSTDERR: msgtype = 211;
pub const MSG_SHUTDOWN: msgtype = 210;
pub const MSG_SHELL: msgtype = 209;
pub const MSG_RESIZE: msgtype = 208;
pub const MSG_READY: msgtype = 207;
pub const MSG_LOCK: msgtype = 206;
pub const MSG_EXITING: msgtype = 205;
pub const MSG_EXITED: msgtype = 204;
pub const MSG_EXIT: msgtype = 203;
pub const MSG_DETACHKILL: msgtype = 202;
pub const MSG_DETACH: msgtype = 201;
pub const MSG_COMMAND: msgtype = 200;
pub const MSG_IDENTIFY_TERMINFO: msgtype = 112;
pub const MSG_IDENTIFY_LONGFLAGS: msgtype = 111;
pub const MSG_IDENTIFY_STDOUT: msgtype = 110;
pub const MSG_IDENTIFY_FEATURES: msgtype = 109;
pub const MSG_IDENTIFY_CWD: msgtype = 108;
pub const MSG_IDENTIFY_CLIENTPID: msgtype = 107;
pub const MSG_IDENTIFY_DONE: msgtype = 106;
pub const MSG_IDENTIFY_ENVIRON: msgtype = 105;
pub const MSG_IDENTIFY_STDIN: msgtype = 104;
pub const MSG_IDENTIFY_OLDCWD: msgtype = 103;
pub const MSG_IDENTIFY_TTYNAME: msgtype = 102;
pub const MSG_IDENTIFY_TERM: msgtype = 101;
pub const MSG_IDENTIFY_FLAGS: msgtype = 100;
pub const MSG_VERSION: msgtype = 12;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client {
    pub name: *const i8,
    pub peer: *mut tmuxpeer,
    pub queue: *mut cmdq_list,
    pub windows: client_windows,
    pub control_state: *mut control_state,
    pub pause_age: u_int,
    pub pid: pid_t,
    pub fd: i32,
    pub out_fd: i32,
    pub event: event,
    pub retval: i32,
    pub creation_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub environ: *mut environ,
    pub jobs: *mut format_job_tree,
    pub title: *mut i8,
    pub path: *mut i8,
    pub cwd: *const i8,
    pub term_name: *mut i8,
    pub term_features: i32,
    pub term_type: *mut i8,
    pub term_caps: *mut *mut i8,
    pub term_ncaps: u_int,
    pub ttyname: *mut i8,
    pub tty: tty,
    pub written: size_t,
    pub discarded: size_t,
    pub redraw: size_t,
    pub repeat_timer: event,
    pub click_timer: event,
    pub click_button: u_int,
    pub click_event: mouse_event,
    pub status: status_line,
    pub flags: uint64_t,
    pub exit_type: C2RustUnnamed_30,
    pub exit_msgtype: msgtype,
    pub exit_session: *mut i8,
    pub exit_message: *mut i8,
    pub keytable: *mut key_table,
    pub last_key: key_code,
    pub redraw_panes: uint64_t,
    pub redraw_scrollbars: uint64_t,
    pub message_ignore_keys: i32,
    pub message_ignore_styles: i32,
    pub message_string: *mut i8,
    pub message_timer: event,
    pub prompt_string: *mut i8,
    pub prompt_buffer: *mut utf8_data,
    pub prompt_last: *mut i8,
    pub prompt_index: size_t,
    pub prompt_inputcb: prompt_input_cb,
    pub prompt_freecb: prompt_free_cb,
    pub prompt_data: *mut (),
    pub prompt_hindex: [u_int; 4],
    pub prompt_mode: C2RustUnnamed_27,
    pub prompt_saved: *mut utf8_data,
    pub prompt_flags: i32,
    pub prompt_type: prompt_type,
    pub prompt_cursor: i32,
    pub session: *mut session,
    pub last_session: *mut session,
    pub references: i32,
    pub pan_window: *mut (),
    pub pan_ox: u_int,
    pub pan_oy: u_int,
    pub overlay_check: overlay_check_cb,
    pub overlay_mode: overlay_mode_cb,
    pub overlay_draw: overlay_draw_cb,
    pub overlay_key: overlay_key_cb,
    pub overlay_free: overlay_free_cb,
    pub overlay_resize: overlay_resize_cb,
    pub overlay_data: *mut (),
    pub overlay_timer: event,
    pub files: client_files,
    pub clipboard_panes: *mut u_int,
    pub clipboard_npanes: u_int,
    pub entry: C2RustUnnamed_8,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_8 {
    pub tqe_next: *mut client,
    pub tqe_prev: *mut *mut client,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_files {
    pub rbh_root: *mut client_file,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_file {
    pub c: *mut client,
    pub peer: *mut tmuxpeer,
    pub tree: *mut client_files,
    pub references: i32,
    pub stream: i32,
    pub path: *mut i8,
    pub buffer: *mut evbuffer,
    pub event: *mut bufferevent,
    pub fd: i32,
    pub error: i32,
    pub closed: i32,
    pub cb: client_file_cb,
    pub data: *mut (),
    pub entry: C2RustUnnamed_9,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_9 {
    pub rbe_left: *mut client_file,
    pub rbe_right: *mut client_file,
    pub rbe_parent: *mut client_file,
    pub rbe_color: i32,
}
pub type client_file_cb = Option<
    unsafe extern "C" fn(*mut client, *const i8, i32, i32, *mut evbuffer, *mut ()) -> (),
>;
pub type overlay_resize_cb = Option<unsafe extern "C" fn(*mut client, *mut ()) -> ()>;
pub type overlay_free_cb = Option<unsafe extern "C" fn(*mut client, *mut ()) -> ()>;
pub type overlay_key_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *mut key_event) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_event {
    pub key: key_code,
    pub m: mouse_event,
    pub buf: *mut i8,
    pub len: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct mouse_event {
    pub valid: i32,
    pub ignore: i32,
    pub key: key_code,
    pub statusat: i32,
    pub statuslines: u_int,
    pub x: u_int,
    pub y: u_int,
    pub b: u_int,
    pub lx: u_int,
    pub ly: u_int,
    pub lb: u_int,
    pub ox: u_int,
    pub oy: u_int,
    pub s: i32,
    pub w: i32,
    pub wp: i32,
    pub sgr_type: u_int,
    pub sgr_b: u_int,
}
pub type key_code = u64;
pub type overlay_draw_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *mut screen_redraw_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen_redraw_ctx {
    pub c: *mut client,
    pub statuslines: u_int,
    pub statustop: i32,
    pub pane_status: i32,
    pub pane_lines: pane_lines,
    pub pane_scrollbars: i32,
    pub pane_scrollbars_pos: i32,
    pub no_pane_gc: grid_cell,
    pub no_pane_gc_set: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub ox: u_int,
    pub oy: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_cell {
    pub data: utf8_data,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct utf8_data {
    pub data: [u_char; 21],
    pub have: u_char,
    pub size: u_char,
    pub width: u_char,
}
pub type pane_lines = u32;
pub const PANE_LINES_NUMBER: pane_lines = 4;
pub const PANE_LINES_SIMPLE: pane_lines = 3;
pub const PANE_LINES_HEAVY: pane_lines = 2;
pub const PANE_LINES_DOUBLE: pane_lines = 1;
pub const PANE_LINES_SINGLE: pane_lines = 0;
pub type overlay_mode_cb = Option<
    unsafe extern "C" fn(*mut client, *mut (), *mut u_int, *mut u_int) -> *mut screen,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen {
    pub title: *mut i8,
    pub path: *mut i8,
    pub titles: *mut screen_titles,
    pub grid: *mut grid,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub default_cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub default_ccolour: i32,
    pub rupper: u_int,
    pub rlower: u_int,
    pub mode: i32,
    pub default_mode: i32,
    pub saved_cx: u_int,
    pub saved_cy: u_int,
    pub saved_grid: *mut grid,
    pub saved_cell: grid_cell,
    pub saved_flags: i32,
    pub tabs: *mut bitstr_t,
    pub sel: *mut screen_sel,
    pub write_list: *mut screen_write_cline,
    pub hyperlinks: *mut hyperlinks,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid {
    pub flags: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub hscrolled: u_int,
    pub hsize: u_int,
    pub hlimit: u_int,
    pub linedata: *mut grid_line,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_line {
    pub celldata: *mut grid_cell_entry,
    pub cellused: u_int,
    pub cellsize: u_int,
    pub extddata: *mut grid_extd_entry,
    pub extdsize: u_int,
    pub flags: i32,
    pub time: time_t,
}
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_extd_entry {
    pub data: utf8_char,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
pub type utf8_char = u_int;
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_cell_entry {
    pub c2rust_unnamed: C2RustUnnamed_10,
    pub flags: u_char,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_10 {
    pub offset: u_int,
    pub data: C2RustUnnamed_11,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_11 {
    pub attr: u_char,
    pub fg: u_char,
    pub bg: u_char,
    pub data: u_char,
}
pub type screen_cursor_style = u32;
pub const SCREEN_CURSOR_BAR: screen_cursor_style = 3;
pub const SCREEN_CURSOR_UNDERLINE: screen_cursor_style = 2;
pub const SCREEN_CURSOR_BLOCK: screen_cursor_style = 1;
pub const SCREEN_CURSOR_DEFAULT: screen_cursor_style = 0;
pub type overlay_check_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *mut (),
        u_int,
        u_int,
        u_int,
        *mut overlay_ranges,
    ) -> (),
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct overlay_ranges {
    pub px: [u_int; 3],
    pub nx: [u_int; 3],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct session {
    pub id: u_int,
    pub name: *mut i8,
    pub cwd: *const i8,
    pub creation_time: timeval,
    pub last_attached_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub lock_timer: event,
    pub curw: *mut winlink,
    pub lastw: winlink_stack,
    pub windows: winlinks,
    pub statusat: i32,
    pub statuslines: u_int,
    pub options: *mut options,
    pub flags: i32,
    pub attached: u_int,
    pub tio: *mut termios,
    pub environ: *mut environ,
    pub references: i32,
    pub gentry: C2RustUnnamed_13,
    pub entry: C2RustUnnamed_12,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_12 {
    pub rbe_left: *mut session,
    pub rbe_right: *mut session,
    pub rbe_parent: *mut session,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_13 {
    pub tqe_next: *mut session,
    pub tqe_prev: *mut *mut session,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlinks {
    pub rbh_root: *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink {
    pub idx: i32,
    pub session: *mut session,
    pub window: *mut window,
    pub flags: i32,
    pub entry: C2RustUnnamed_16,
    pub wentry: C2RustUnnamed_15,
    pub sentry: C2RustUnnamed_14,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_14 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_15 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_16 {
    pub rbe_left: *mut winlink,
    pub rbe_right: *mut winlink,
    pub rbe_parent: *mut winlink,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window {
    pub id: u_int,
    pub latest: *mut (),
    pub name: *mut i8,
    pub name_event: event,
    pub name_time: timeval,
    pub alerts_timer: event,
    pub offset_timer: event,
    pub activity_time: timeval,
    pub active: *mut window_pane,
    pub last_panes: window_panes,
    pub panes: window_panes,
    pub lastlayout: i32,
    pub layout_root: *mut layout_cell,
    pub saved_layout_root: *mut layout_cell,
    pub old_layout: *mut i8,
    pub sx: u_int,
    pub sy: u_int,
    pub manual_sx: u_int,
    pub manual_sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub new_sx: u_int,
    pub new_sy: u_int,
    pub new_xpixel: u_int,
    pub new_ypixel: u_int,
    pub fill_character: *mut utf8_data,
    pub flags: i32,
    pub alerts_queued: i32,
    pub alerts_entry: C2RustUnnamed_19,
    pub options: *mut options,
    pub references: u_int,
    pub winlinks: C2RustUnnamed_18,
    pub entry: C2RustUnnamed_17,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_17 {
    pub rbe_left: *mut window,
    pub rbe_right: *mut window,
    pub rbe_parent: *mut window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_18 {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_19 {
    pub tqe_next: *mut window,
    pub tqe_prev: *mut *mut window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cell {
    pub type_0: layout_type,
    pub parent: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub wp: *mut window_pane,
    pub cells: layout_cells,
    pub entry: C2RustUnnamed_20,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_20 {
    pub tqe_next: *mut layout_cell,
    pub tqe_prev: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cells {
    pub tqh_first: *mut layout_cell,
    pub tqh_last: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane {
    pub id: u_int,
    pub active_point: u_int,
    pub window: *mut window,
    pub options: *mut options,
    pub layout_cell: *mut layout_cell,
    pub saved_layout_cell: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub flags: i32,
    pub sb_slider_y: u_int,
    pub sb_slider_h: u_int,
    pub argc: i32,
    pub argv: *mut *mut i8,
    pub shell: *mut i8,
    pub cwd: *mut i8,
    pub pid: pid_t,
    pub tty: [i8; 32],
    pub status: i32,
    pub dead_time: timeval,
    pub fd: i32,
    pub event: *mut bufferevent,
    pub offset: window_pane_offset,
    pub base_offset: size_t,
    pub resize_queue: window_pane_resizes,
    pub resize_timer: event,
    pub ictx: *mut input_ctx,
    pub cached_gc: grid_cell,
    pub cached_active_gc: grid_cell,
    pub palette: colour_palette,
    pub pipe_fd: i32,
    pub pipe_event: *mut bufferevent,
    pub pipe_offset: window_pane_offset,
    pub screen: *mut screen,
    pub base: screen,
    pub status_screen: screen,
    pub status_size: size_t,
    pub modes: C2RustUnnamed_24,
    pub searchstr: *mut i8,
    pub searchregex: i32,
    pub border_gc_set: i32,
    pub border_gc: grid_cell,
    pub control_bg: i32,
    pub control_fg: i32,
    pub scrollbar_style: style,
    pub entry: C2RustUnnamed_23,
    pub sentry: C2RustUnnamed_22,
    pub tree_entry: C2RustUnnamed_21,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_21 {
    pub rbe_left: *mut window_pane,
    pub rbe_right: *mut window_pane,
    pub rbe_parent: *mut window_pane,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_22 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_23 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style {
    pub gc: grid_cell,
    pub ignore: i32,
    pub fill: i32,
    pub align: style_align,
    pub list: style_list,
    pub range_type: style_range_type,
    pub range_argument: u_int,
    pub range_string: [i8; 16],
    pub width: i32,
    pub pad: i32,
    pub default_type: style_default_type,
}
pub type style_default_type = u32;
pub const STYLE_DEFAULT_POP: style_default_type = 2;
pub const STYLE_DEFAULT_PUSH: style_default_type = 1;
pub const STYLE_DEFAULT_BASE: style_default_type = 0;
pub type style_range_type = u32;
pub const STYLE_RANGE_USER: style_range_type = 6;
pub const STYLE_RANGE_SESSION: style_range_type = 5;
pub const STYLE_RANGE_WINDOW: style_range_type = 4;
pub const STYLE_RANGE_PANE: style_range_type = 3;
pub const STYLE_RANGE_RIGHT: style_range_type = 2;
pub const STYLE_RANGE_LEFT: style_range_type = 1;
pub const STYLE_RANGE_NONE: style_range_type = 0;
pub type style_list = u32;
pub const STYLE_LIST_RIGHT_MARKER: style_list = 4;
pub const STYLE_LIST_LEFT_MARKER: style_list = 3;
pub const STYLE_LIST_FOCUS: style_list = 2;
pub const STYLE_LIST_ON: style_list = 1;
pub const STYLE_LIST_OFF: style_list = 0;
pub type style_align = u32;
pub const STYLE_ALIGN_ABSOLUTE_CENTRE: style_align = 4;
pub const STYLE_ALIGN_RIGHT: style_align = 3;
pub const STYLE_ALIGN_CENTRE: style_align = 2;
pub const STYLE_ALIGN_LEFT: style_align = 1;
pub const STYLE_ALIGN_DEFAULT: style_align = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_24 {
    pub tqh_first: *mut window_mode_entry,
    pub tqh_last: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode_entry {
    pub wp: *mut window_pane,
    pub swp: *mut window_pane,
    pub mode: *const window_mode,
    pub data: *mut (),
    pub screen: *mut screen,
    pub prefix: u_int,
    pub entry: C2RustUnnamed_25,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_25 {
    pub tqe_next: *mut window_mode_entry,
    pub tqe_prev: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode {
    pub name: *const i8,
    pub default_format: *const i8,
    pub init: Option<
        unsafe extern "C" fn(*mut window_mode_entry, *mut cmd_find_state, *mut args) -> *mut screen,
    >,
    pub free: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub resize: Option<unsafe extern "C" fn(*mut window_mode_entry, u_int, u_int) -> ()>,
    pub update: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub key: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            key_code,
            *mut mouse_event,
        ) -> (),
    >,
    pub key_table: Option<unsafe extern "C" fn(*mut window_mode_entry) -> *const i8>,
    pub command: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            *mut args,
            *mut mouse_event,
        ) -> (),
    >,
    pub formats: Option<unsafe extern "C" fn(*mut window_mode_entry, *mut format_tree) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_find_state {
    pub flags: i32,
    pub current: *mut cmd_find_state,
    pub s: *mut session,
    pub wl: *mut winlink,
    pub w: *mut window,
    pub wp: *mut window_pane,
    pub idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_offset {
    pub used: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct colour_palette {
    pub fg: i32,
    pub bg: i32,
    pub palette: *mut i32,
    pub default_palette: *mut i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resizes {
    pub tqh_first: *mut window_pane_resize,
    pub tqh_last: *mut *mut window_pane_resize,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resize {
    pub sx: u_int,
    pub sy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub entry: C2RustUnnamed_26,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_26 {
    pub tqe_next: *mut window_pane_resize,
    pub tqe_prev: *mut *mut window_pane_resize,
}
pub type layout_type = u32;
pub const LAYOUT_WINDOWPANE: layout_type = 2;
pub const LAYOUT_TOPBOTTOM: layout_type = 1;
pub const LAYOUT_LEFTRIGHT: layout_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_panes {
    pub tqh_first: *mut window_pane,
    pub tqh_last: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink_stack {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
pub type prompt_type = u32;
pub const PROMPT_TYPE_INVALID: prompt_type = 255;
pub const PROMPT_TYPE_WINDOW_TARGET: prompt_type = 3;
pub const PROMPT_TYPE_TARGET: prompt_type = 2;
pub const PROMPT_TYPE_SEARCH: prompt_type = 1;
pub const PROMPT_TYPE_COMMAND: prompt_type = 0;
pub type C2RustUnnamed_27 = u32;
pub const PROMPT_COMMAND: C2RustUnnamed_27 = 1;
pub const PROMPT_ENTRY: C2RustUnnamed_27 = 0;
pub type prompt_free_cb = Option<unsafe extern "C" fn(*mut ()) -> ()>;
pub type prompt_input_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *const i8, i32) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_table {
    pub name: *const i8,
    pub activity_time: timeval,
    pub key_bindings: key_bindings,
    pub default_key_bindings: key_bindings,
    pub references: u_int,
    pub entry: C2RustUnnamed_28,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_28 {
    pub rbe_left: *mut key_table,
    pub rbe_right: *mut key_table,
    pub rbe_parent: *mut key_table,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_bindings {
    pub rbh_root: *mut key_binding,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_binding {
    pub key: key_code,
    pub cmdlist: *mut cmd_list,
    pub note: *const i8,
    pub flags: i32,
    pub entry: C2RustUnnamed_29,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_29 {
    pub rbe_left: *mut key_binding,
    pub rbe_right: *mut key_binding,
    pub rbe_parent: *mut key_binding,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_list {
    pub references: i32,
    pub group: u_int,
    pub list: *mut cmds,
}
pub type C2RustUnnamed_30 = u32;
pub const CLIENT_EXIT_DETACH: C2RustUnnamed_30 = 2;
pub const CLIENT_EXIT_SHUTDOWN: C2RustUnnamed_30 = 1;
pub const CLIENT_EXIT_RETURN: C2RustUnnamed_30 = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line {
    pub timer: event,
    pub screen: screen,
    pub active: *mut screen,
    pub references: i32,
    pub style: grid_cell,
    pub entries: [status_line_entry; 5],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line_entry {
    pub expanded: *mut i8,
    pub ranges: style_ranges,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_ranges {
    pub tqh_first: *mut style_range,
    pub tqh_last: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_range {
    pub type_0: style_range_type,
    pub argument: u_int,
    pub string: [i8; 16],
    pub start: u_int,
    pub end: u_int,
    pub entry: C2RustUnnamed_31,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_31 {
    pub tqe_next: *mut style_range,
    pub tqe_prev: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty {
    pub client: *mut client,
    pub start_timer: event,
    pub clipboard_timer: event,
    pub last_requests: time_t,
    pub sx: u_int,
    pub sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub oflag: i32,
    pub oox: u_int,
    pub ooy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub mode: i32,
    pub fg: i32,
    pub bg: i32,
    pub rlower: u_int,
    pub rupper: u_int,
    pub rleft: u_int,
    pub rright: u_int,
    pub event_in: event,
    pub in_0: *mut evbuffer,
    pub event_out: event,
    pub out: *mut evbuffer,
    pub timer: event,
    pub discarded: size_t,
    pub tio: termios,
    pub cell: grid_cell,
    pub last_cell: grid_cell,
    pub flags: i32,
    pub term: *mut tty_term,
    pub mouse_last_x: u_int,
    pub mouse_last_y: u_int,
    pub mouse_last_b: u_int,
    pub mouse_drag_flag: i32,
    pub mouse_scrolling_flag: i32,
    pub mouse_slider_mpos: i32,
    pub mouse_drag_update: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub mouse_drag_release: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub key_timer: event,
    pub key_tree: *mut tty_key,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty_term {
    pub name: *mut i8,
    pub tty: *mut tty,
    pub features: i32,
    pub acs: [[i8; 2]; 256],
    pub codes: *mut tty_code,
    pub flags: i32,
    pub entry: C2RustUnnamed_32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_32 {
    pub le_next: *mut tty_term,
    pub le_prev: *mut *mut tty_term,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_windows {
    pub rbh_root: *mut client_window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_window {
    pub window: u_int,
    pub pane: *mut window_pane,
    pub sx: u_int,
    pub sy: u_int,
    pub entry: C2RustUnnamed_33,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_33 {
    pub rbe_left: *mut client_window,
    pub rbe_right: *mut client_window,
    pub rbe_parent: *mut client_window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_tree {
    pub rbh_root: *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct environ_entry {
    pub name: *mut i8,
    pub value: *mut i8,
    pub flags: i32,
    pub entry: C2RustUnnamed_34,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_34 {
    pub rbe_left: *mut environ_entry,
    pub rbe_right: *mut environ_entry,
    pub rbe_parent: *mut environ_entry,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sessions {
    pub rbh_root: *mut session,
}
pub type cmd_find_type = u32;
pub const CMD_FIND_SESSION: cmd_find_type = 2;
pub const CMD_FIND_WINDOW: cmd_find_type = 1;
pub const CMD_FIND_PANE: cmd_find_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct clients {
    pub tqh_first: *mut client,
    pub tqh_last: *mut *mut client,
}
static mut cmd_find_session_table: [[*const i8; 2]; 1] = [[0 as *const i8, 0 as *const i8]];
static mut cmd_find_window_table: [[*const i8; 2]; 6] = [
    [
        b"{start}\0" as *const u8 as *const i8,
        b"^\0" as *const u8 as *const i8,
    ],
    [
        b"{last}\0" as *const u8 as *const i8,
        b"!\0" as *const u8 as *const i8,
    ],
    [
        b"{end}\0" as *const u8 as *const i8,
        b"$\0" as *const u8 as *const i8,
    ],
    [
        b"{next}\0" as *const u8 as *const i8,
        b"+\0" as *const u8 as *const i8,
    ],
    [
        b"{previous}\0" as *const u8 as *const i8,
        b"-\0" as *const u8 as *const i8,
    ],
    [0 as *const i8, 0 as *const i8],
];
static mut cmd_find_pane_table: [[*const i8; 2]; 16] = [
    [
        b"{last}\0" as *const u8 as *const i8,
        b"!\0" as *const u8 as *const i8,
    ],
    [
        b"{next}\0" as *const u8 as *const i8,
        b"+\0" as *const u8 as *const i8,
    ],
    [
        b"{previous}\0" as *const u8 as *const i8,
        b"-\0" as *const u8 as *const i8,
    ],
    [
        b"{top}\0" as *const u8 as *const i8,
        b"top\0" as *const u8 as *const i8,
    ],
    [
        b"{bottom}\0" as *const u8 as *const i8,
        b"bottom\0" as *const u8 as *const i8,
    ],
    [
        b"{left}\0" as *const u8 as *const i8,
        b"left\0" as *const u8 as *const i8,
    ],
    [
        b"{right}\0" as *const u8 as *const i8,
        b"right\0" as *const u8 as *const i8,
    ],
    [
        b"{top-left}\0" as *const u8 as *const i8,
        b"top-left\0" as *const u8 as *const i8,
    ],
    [
        b"{top-right}\0" as *const u8 as *const i8,
        b"top-right\0" as *const u8 as *const i8,
    ],
    [
        b"{bottom-left}\0" as *const u8 as *const i8,
        b"bottom-left\0" as *const u8 as *const i8,
    ],
    [
        b"{bottom-right}\0" as *const u8 as *const i8,
        b"bottom-right\0" as *const u8 as *const i8,
    ],
    [
        b"{up-of}\0" as *const u8 as *const i8,
        b"{up-of}\0" as *const u8 as *const i8,
    ],
    [
        b"{down-of}\0" as *const u8 as *const i8,
        b"{down-of}\0" as *const u8 as *const i8,
    ],
    [
        b"{left-of}\0" as *const u8 as *const i8,
        b"{left-of}\0" as *const u8 as *const i8,
    ],
    [
        b"{right-of}\0" as *const u8 as *const i8,
        b"{right-of}\0" as *const u8 as *const i8,
    ],
    [0 as *const i8, 0 as *const i8],
];
extern "C" fn cmd_find_inside_pane(mut c: *mut client) -> *mut window_pane {
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    let mut envent: *mut environ_entry = std::ptr::null_mut::<environ_entry>();
    if c.is_null() {
        return std::ptr::null_mut::<window_pane>();
    }
    wp = unsafe { window_pane_tree_RB_MINMAX(&mut all_window_panes, -(1 as i32)) };
    while !wp.is_null() {
        if (unsafe { (*wp).fd }) != -(1 as i32)
            && (unsafe { strcmp(((*wp).tty).as_mut_ptr(), (*c).ttyname) }) == 0
        {
            break;
        }
        wp = unsafe { window_pane_tree_RB_NEXT(wp) };
    }
    if wp.is_null() {
        envent = unsafe { environ_find((*c).environ, b"TMUX_PANE\0" as *const u8 as *const i8) };
        if !envent.is_null() {
            wp = unsafe { window_pane_find_by_id_str((*envent).value) };
        }
    }
    if !wp.is_null() {
        (unsafe {
            log_debug(
                b"%s: got pane %%%u (%s)\0" as *const u8 as *const i8,
                (*::core::mem::transmute::<&[u8; 21], &[i8; 21]>(b"cmd_find_inside_pane\0"))
                    .as_ptr(),
                (*wp).id,
                ((*wp).tty).as_mut_ptr(),
            )
        });
    }
    return wp;
}
extern "C" fn cmd_find_client_better(mut c: *mut client, mut than: *mut client) -> i32 {
    if than.is_null() {
        return 1;
    }
    return if (unsafe { (*c).activity_time.tv_sec }) == (unsafe { (*than).activity_time.tv_sec }) {
        ((unsafe { (*c).activity_time.tv_usec }) > (unsafe { (*than).activity_time.tv_usec }))
            as i32
    } else {
        ((unsafe { (*c).activity_time.tv_sec }) > (unsafe { (*than).activity_time.tv_sec })) as i32
    };
}
#[no_mangle]
pub extern "C" fn cmd_find_best_client(mut s: *mut session) -> *mut client {
    let mut c_loop: *mut client = std::ptr::null_mut::<client>();
    let mut c: *mut client = std::ptr::null_mut::<client>();
    if (unsafe { (*s).attached }) == 0 as u32 {
        s = std::ptr::null_mut::<session>();
    }
    c = std::ptr::null_mut::<client>();
    c_loop = unsafe { clients.tqh_first };
    while !c_loop.is_null() {
        if !(unsafe { (*c_loop).session }).is_null() {
            if s.is_null() || (unsafe { (*c_loop).session }) == s {
                if cmd_find_client_better(c_loop, c) != 0 {
                    c = c_loop;
                }
            }
        }
        c_loop = unsafe { (*c_loop).entry.tqe_next };
    }
    return c;
}
extern "C" fn cmd_find_session_better(
    mut s: *mut session,
    mut than: *mut session,
    mut flags: i32,
) -> i32 {
    let mut attached: i32 = 0;
    if than.is_null() {
        return 1;
    }
    if flags & 0x1 as i32 != 0 {
        attached = ((unsafe { (*than).attached }) != 0 as u32) as i32;
        if attached != 0 && (unsafe { (*s).attached }) == 0 as u32 {
            return 1;
        } else {
            if attached == 0 && (unsafe { (*s).attached }) != 0 as u32 {
                return 0;
            }
        }
    }
    return if (unsafe { (*s).activity_time.tv_sec }) == (unsafe { (*than).activity_time.tv_sec }) {
        ((unsafe { (*s).activity_time.tv_usec }) > (unsafe { (*than).activity_time.tv_usec }))
            as i32
    } else {
        ((unsafe { (*s).activity_time.tv_sec }) > (unsafe { (*than).activity_time.tv_sec })) as i32
    };
}
extern "C" fn cmd_find_best_session(
    mut slist: *mut *mut session,
    mut ssize: u_int,
    mut flags: i32,
) -> *mut session {
    let mut s_loop: *mut session = std::ptr::null_mut::<session>();
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut i: u_int = 0;
    (unsafe {
        log_debug(
            b"%s: %u sessions to try\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 22], &[i8; 22]>(b"cmd_find_best_session\0")).as_ptr(),
            ssize,
        )
    });
    s = std::ptr::null_mut::<session>();
    if !slist.is_null() {
        i = 0 as u_int;
        while i < ssize {
            if cmd_find_session_better(unsafe { *slist.offset(i as isize) }, s, flags) != 0 {
                s = unsafe { *slist.offset(i as isize) };
            }
            i = i.wrapping_add(1);
        }
    } else {
        s_loop = unsafe { sessions_RB_MINMAX(&mut sessions, -(1 as i32)) };
        while !s_loop.is_null() {
            if cmd_find_session_better(s_loop, s, flags) != 0 {
                s = s_loop;
            }
            s_loop = unsafe { sessions_RB_NEXT(s_loop) };
        }
    }
    return s;
}
extern "C" fn cmd_find_best_session_with_window(mut fs: *mut cmd_find_state) -> i32 {
    let mut slist: *mut *mut session = std::ptr::null_mut::<*mut session>();
    let mut ssize: u_int = 0;
    let mut s: *mut session = std::ptr::null_mut::<session>();
    (unsafe {
        log_debug(
            b"%s: window is @%u\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 34], &[i8; 34]>(
                b"cmd_find_best_session_with_window\0",
            ))
            .as_ptr(),
            (*(*fs).w).id,
        )
    });
    ssize = 0 as u_int;
    s = unsafe { sessions_RB_MINMAX(&mut sessions, -(1 as i32)) };
    while !s.is_null() {
        if (unsafe { session_has(s, (*fs).w) }) != 0 {
            slist = (unsafe {
                xreallocarray(
                    slist as *mut (),
                    ssize.wrapping_add(1 as i32 as u32) as size_t,
                    ::core::mem::size_of::<*mut session>() as u64,
                )
            }) as *mut *mut session;
            let fresh0 = ssize;
            ssize = ssize.wrapping_add(1);
            let fresh1 = unsafe { &mut (*slist.offset(fresh0 as isize)) };
            *fresh1 = s;
        }
        s = unsafe { sessions_RB_NEXT(s) };
    }
    if ssize != 0 as u32 {
        (unsafe { (*fs).s = cmd_find_best_session(slist, ssize, (*fs).flags) });
        if !(unsafe { (*fs).s }).is_null() {
            (unsafe { free(slist as *mut ()) });
            return cmd_find_best_winlink_with_window(fs);
        }
    }
    (unsafe { free(slist as *mut ()) });
    return -(1 as i32);
}
extern "C" fn cmd_find_best_winlink_with_window(mut fs: *mut cmd_find_state) -> i32 {
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    let mut wl_loop: *mut winlink = std::ptr::null_mut::<winlink>();
    (unsafe {
        log_debug(
            b"%s: window is @%u\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 34], &[i8; 34]>(
                b"cmd_find_best_winlink_with_window\0",
            ))
            .as_ptr(),
            (*(*fs).w).id,
        )
    });
    wl = std::ptr::null_mut::<winlink>();
    if !(unsafe { (*(*fs).s).curw }).is_null()
        && (unsafe { (*(*(*fs).s).curw).window }) == (unsafe { (*fs).w })
    {
        wl = unsafe { (*(*fs).s).curw };
    } else {
        wl_loop = unsafe { winlinks_RB_MINMAX(&mut (*(*fs).s).windows, -(1 as i32)) };
        while !wl_loop.is_null() {
            if (unsafe { (*wl_loop).window }) == (unsafe { (*fs).w }) {
                wl = wl_loop;
                break;
            } else {
                wl_loop = unsafe { winlinks_RB_NEXT(wl_loop) };
            }
        }
    }
    if wl.is_null() {
        return -(1 as i32);
    }
    (unsafe { (*fs).wl = wl });
    (unsafe { (*fs).idx = (*(*fs).wl).idx });
    return 0;
}
extern "C" fn cmd_find_map_table(mut table: *mut [*const i8; 2], mut s: *const i8) -> *const i8 {
    let mut i: u_int = 0;
    i = 0 as u_int;
    while !(unsafe { (*table.offset(i as isize))[0 as i32 as usize] }).is_null() {
        if (unsafe { strcmp(s, (*table.offset(i as isize))[0 as i32 as usize]) }) == 0 {
            return unsafe { (*table.offset(i as isize))[1 as i32 as usize] };
        }
        i = i.wrapping_add(1);
    }
    return s;
}
extern "C" fn cmd_find_get_session(mut fs: *mut cmd_find_state, mut session: *const i8) -> i32 {
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut s_loop: *mut session = std::ptr::null_mut::<session>();
    let mut c: *mut client = std::ptr::null_mut::<client>();
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 21], &[i8; 21]>(b"cmd_find_get_session\0")).as_ptr(),
            session,
        )
    });
    if (unsafe { *session }) as i32 == '$' as i32 {
        (unsafe { (*fs).s = session_find_by_id_str(session) });
        if (unsafe { (*fs).s }).is_null() {
            return -(1 as i32);
        }
        return 0;
    }
    (unsafe { (*fs).s = session_find(session) });
    if !(unsafe { (*fs).s }).is_null() {
        return 0;
    }
    c = cmd_find_client(std::ptr::null_mut::<cmdq_item>(), session, 1);
    if !c.is_null() && !(unsafe { (*c).session }).is_null() {
        (unsafe { (*fs).s = (*c).session });
        return 0;
    }
    if (unsafe { (*fs).flags }) & 0x10 as i32 != 0 {
        return -(1 as i32);
    }
    s = std::ptr::null_mut::<session>();
    s_loop = unsafe { sessions_RB_MINMAX(&mut sessions, -(1 as i32)) };
    while !s_loop.is_null() {
        if (unsafe { strncmp(session, (*s_loop).name, strlen(session)) }) == 0 {
            if !s.is_null() {
                return -(1 as i32);
            }
            s = s_loop;
        }
        s_loop = unsafe { sessions_RB_NEXT(s_loop) };
    }
    if !s.is_null() {
        (unsafe { (*fs).s = s });
        return 0;
    }
    s = std::ptr::null_mut::<session>();
    s_loop = unsafe { sessions_RB_MINMAX(&mut sessions, -(1 as i32)) };
    while !s_loop.is_null() {
        if (unsafe { fnmatch(session, (*s_loop).name, 0) }) == 0 {
            if !s.is_null() {
                return -(1 as i32);
            }
            s = s_loop;
        }
        s_loop = unsafe { sessions_RB_NEXT(s_loop) };
    }
    if !s.is_null() {
        (unsafe { (*fs).s = s });
        return 0;
    }
    return -(1 as i32);
}
extern "C" fn cmd_find_get_window(
    mut fs: *mut cmd_find_state,
    mut window: *const i8,
    mut only: i32,
) -> i32 {
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 20], &[i8; 20]>(b"cmd_find_get_window\0")).as_ptr(),
            window,
        )
    });
    if (unsafe { *window }) as i32 == '@' as i32 {
        (unsafe { (*fs).w = window_find_by_id_str(window) });
        if (unsafe { (*fs).w }).is_null() {
            return -(1 as i32);
        }
        return cmd_find_best_session_with_window(fs);
    }
    (unsafe { (*fs).s = (*(*fs).current).s });
    if cmd_find_get_window_with_session(fs, window) == 0 {
        return 0;
    }
    if only == 0 && cmd_find_get_session(fs, window) == 0 {
        (unsafe { (*fs).wl = (*(*fs).s).curw });
        (unsafe { (*fs).w = (*(*fs).wl).window });
        if !(unsafe { (*fs).flags }) & 0x4 as i32 != 0 {
            (unsafe { (*fs).idx = (*(*fs).wl).idx });
        }
        return 0;
    }
    return -(1 as i32);
}
extern "C" fn cmd_find_get_window_with_session(
    mut fs: *mut cmd_find_state,
    mut window: *const i8,
) -> i32 {
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    let mut errstr: *const i8 = std::ptr::null::<i8>();
    let mut idx: i32 = 0;
    let mut n: i32 = 0;
    let mut exact: i32 = 0;
    let mut s: *mut session = std::ptr::null_mut::<session>();
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 33], &[i8; 33]>(
                b"cmd_find_get_window_with_session\0",
            ))
            .as_ptr(),
            window,
        )
    });
    exact = (unsafe { (*fs).flags }) & 0x20 as i32;
    (unsafe { (*fs).wl = (*(*fs).s).curw });
    (unsafe { (*fs).w = (*(*fs).wl).window });
    if (unsafe { *window }) as i32 == '@' as i32 {
        (unsafe { (*fs).w = window_find_by_id_str(window) });
        if (unsafe { (*fs).w }).is_null() || (unsafe { session_has((*fs).s, (*fs).w) }) == 0 {
            return -(1 as i32);
        }
        return cmd_find_best_winlink_with_window(fs);
    }
    if exact == 0
        && ((unsafe { *window.offset(0 as i32 as isize) }) as i32 == '+' as i32
            || (unsafe { *window.offset(0 as i32 as isize) }) as i32 == '-' as i32)
    {
        if (unsafe { *window.offset(1 as i32 as isize) }) as i32 != '\0' as i32 {
            n = (unsafe {
                strtonum(
                    window.offset(1 as i32 as isize), 1 as i64, 2147483647 as i64,
                    std::ptr::null_mut::<*const i8>(),
                )
            }) as i32;
        } else {
            n = 1;
        }
        s = unsafe { (*fs).s };
        if (unsafe { (*fs).flags }) & 0x4 as i32 != 0 {
            if (unsafe { *window.offset(0 as i32 as isize) }) as i32 == '+' as i32 {
                if 2147483647 - (unsafe { (*(*s).curw).idx }) < n {
                    return -(1 as i32);
                }
                (unsafe { (*fs).idx = (*(*s).curw).idx + n });
            } else {
                if n > (unsafe { (*(*s).curw).idx }) {
                    return -(1 as i32);
                }
                (unsafe { (*fs).idx = (*(*s).curw).idx - n });
            }
            return 0;
        }
        if (unsafe { *window.offset(0 as i32 as isize) }) as i32 == '+' as i32 {
            (unsafe { (*fs).wl = winlink_next_by_number((*s).curw, s, n) });
        } else {
            (unsafe { (*fs).wl = winlink_previous_by_number((*s).curw, s, n) });
        }
        if !(unsafe { (*fs).wl }).is_null() {
            (unsafe { (*fs).idx = (*(*fs).wl).idx });
            (unsafe { (*fs).w = (*(*fs).wl).window });
            return 0;
        }
    }
    if exact == 0 {
        if (unsafe { strcmp(window, b"!\0" as *const u8 as *const i8) }) == 0 {
            (unsafe { (*fs).wl = (*(*fs).s).lastw.tqh_first });
            if (unsafe { (*fs).wl }).is_null() {
                return -(1 as i32);
            }
            (unsafe { (*fs).idx = (*(*fs).wl).idx });
            (unsafe { (*fs).w = (*(*fs).wl).window });
            return 0;
        } else {
            if (unsafe { strcmp(window, b"^\0" as *const u8 as *const i8) }) == 0 {
                (unsafe { (*fs).wl = winlinks_RB_MINMAX(&mut (*(*fs).s).windows, -(1 as i32)) });
                if (unsafe { (*fs).wl }).is_null() {
                    return -(1 as i32);
                }
                (unsafe { (*fs).idx = (*(*fs).wl).idx });
                (unsafe { (*fs).w = (*(*fs).wl).window });
                return 0;
            } else {
                if (unsafe { strcmp(window, b"$\0" as *const u8 as *const i8) }) == 0 {
                    (unsafe { (*fs).wl = winlinks_RB_MINMAX(&mut (*(*fs).s).windows, 1) });
                    if (unsafe { (*fs).wl }).is_null() {
                        return -(1 as i32);
                    }
                    (unsafe { (*fs).idx = (*(*fs).wl).idx });
                    (unsafe { (*fs).w = (*(*fs).wl).window });
                    return 0;
                }
            }
        }
    }
    if (unsafe { *window.offset(0 as i32 as isize) }) as i32 != '+' as i32
        && (unsafe { *window.offset(0 as i32 as isize) }) as i32 != '-' as i32
    {
        idx = (unsafe {
            strtonum(
                window, 0 as i64, 2147483647 as i64,
                &mut errstr,
            )
        }) as i32;
        if errstr.is_null() {
            (unsafe { (*fs).wl = winlink_find_by_index(&mut (*(*fs).s).windows, idx) });
            if !(unsafe { (*fs).wl }).is_null() {
                (unsafe { (*fs).idx = (*(*fs).wl).idx });
                (unsafe { (*fs).w = (*(*fs).wl).window });
                return 0;
            }
            if (unsafe { (*fs).flags }) & 0x4 as i32 != 0 {
                (unsafe { (*fs).idx = idx });
                return 0;
            }
        }
    }
    (unsafe { (*fs).wl = std::ptr::null_mut::<winlink>() });
    wl = unsafe { winlinks_RB_MINMAX(&mut (*(*fs).s).windows, -(1 as i32)) };
    while !wl.is_null() {
        if (unsafe { strcmp(window, (*(*wl).window).name) }) == 0 {
            if !(unsafe { (*fs).wl }).is_null() {
                return -(1 as i32);
            }
            (unsafe { (*fs).wl = wl });
        }
        wl = unsafe { winlinks_RB_NEXT(wl) };
    }
    if !(unsafe { (*fs).wl }).is_null() {
        (unsafe { (*fs).idx = (*(*fs).wl).idx });
        (unsafe { (*fs).w = (*(*fs).wl).window });
        return 0;
    }
    if exact != 0 {
        return -(1 as i32);
    }
    (unsafe { (*fs).wl = std::ptr::null_mut::<winlink>() });
    wl = unsafe { winlinks_RB_MINMAX(&mut (*(*fs).s).windows, -(1 as i32)) };
    while !wl.is_null() {
        if (unsafe { strncmp(window, (*(*wl).window).name, strlen(window)) }) == 0 {
            if !(unsafe { (*fs).wl }).is_null() {
                return -(1 as i32);
            }
            (unsafe { (*fs).wl = wl });
        }
        wl = unsafe { winlinks_RB_NEXT(wl) };
    }
    if !(unsafe { (*fs).wl }).is_null() {
        (unsafe { (*fs).idx = (*(*fs).wl).idx });
        (unsafe { (*fs).w = (*(*fs).wl).window });
        return 0;
    }
    (unsafe { (*fs).wl = std::ptr::null_mut::<winlink>() });
    wl = unsafe { winlinks_RB_MINMAX(&mut (*(*fs).s).windows, -(1 as i32)) };
    while !wl.is_null() {
        if (unsafe { fnmatch(window, (*(*wl).window).name, 0) }) == 0 {
            if !(unsafe { (*fs).wl }).is_null() {
                return -(1 as i32);
            }
            (unsafe { (*fs).wl = wl });
        }
        wl = unsafe { winlinks_RB_NEXT(wl) };
    }
    if !(unsafe { (*fs).wl }).is_null() {
        (unsafe { (*fs).idx = (*(*fs).wl).idx });
        (unsafe { (*fs).w = (*(*fs).wl).window });
        return 0;
    }
    return -(1 as i32);
}
extern "C" fn cmd_find_get_pane(
    mut fs: *mut cmd_find_state,
    mut pane: *const i8,
    mut only: i32,
) -> i32 {
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 18], &[i8; 18]>(b"cmd_find_get_pane\0")).as_ptr(),
            pane,
        )
    });
    if (unsafe { *pane }) as i32 == '%' as i32 {
        (unsafe { (*fs).wp = window_pane_find_by_id_str(pane) });
        if (unsafe { (*fs).wp }).is_null() {
            return -(1 as i32);
        }
        (unsafe { (*fs).w = (*(*fs).wp).window });
        return cmd_find_best_session_with_window(fs);
    }
    (unsafe { (*fs).s = (*(*fs).current).s });
    (unsafe { (*fs).wl = (*(*fs).current).wl });
    (unsafe { (*fs).idx = (*(*fs).current).idx });
    (unsafe { (*fs).w = (*(*fs).current).w });
    if cmd_find_get_pane_with_window(fs, pane) == 0 {
        return 0;
    }
    if only == 0 && cmd_find_get_window(fs, pane, 0) == 0 {
        (unsafe { (*fs).wp = (*(*fs).w).active });
        return 0;
    }
    return -(1 as i32);
}
extern "C" fn cmd_find_get_pane_with_session(
    mut fs: *mut cmd_find_state,
    mut pane: *const i8,
) -> i32 {
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 31], &[i8; 31]>(b"cmd_find_get_pane_with_session\0"))
                .as_ptr(),
            pane,
        )
    });
    if (unsafe { *pane }) as i32 == '%' as i32 {
        (unsafe { (*fs).wp = window_pane_find_by_id_str(pane) });
        if (unsafe { (*fs).wp }).is_null() {
            return -(1 as i32);
        }
        (unsafe { (*fs).w = (*(*fs).wp).window });
        return cmd_find_best_winlink_with_window(fs);
    }
    (unsafe { (*fs).wl = (*(*fs).s).curw });
    (unsafe { (*fs).idx = (*(*fs).wl).idx });
    (unsafe { (*fs).w = (*(*fs).wl).window });
    return cmd_find_get_pane_with_window(fs, pane);
}
extern "C" fn cmd_find_get_pane_with_window(
    mut fs: *mut cmd_find_state,
    mut pane: *const i8,
) -> i32 {
    let mut errstr: *const i8 = std::ptr::null::<i8>();
    let mut idx: i32 = 0;
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    let mut n: u_int = 0;
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 30], &[i8; 30]>(b"cmd_find_get_pane_with_window\0"))
                .as_ptr(),
            pane,
        )
    });
    if (unsafe { *pane }) as i32 == '%' as i32 {
        (unsafe { (*fs).wp = window_pane_find_by_id_str(pane) });
        if (unsafe { (*fs).wp }).is_null() {
            return -(1 as i32);
        }
        if (unsafe { (*(*fs).wp).window }) != (unsafe { (*fs).w }) {
            return -(1 as i32);
        }
        return 0;
    }
    if (unsafe { strcmp(pane, b"!\0" as *const u8 as *const i8) }) == 0 {
        (unsafe { (*fs).wp = (*(*fs).w).last_panes.tqh_first });
        if (unsafe { (*fs).wp }).is_null() {
            return -(1 as i32);
        }
        return 0;
    } else {
        if (unsafe { strcmp(pane, b"{up-of}\0" as *const u8 as *const i8) }) == 0 {
            (unsafe { (*fs).wp = window_pane_find_up((*(*fs).w).active) });
            if (unsafe { (*fs).wp }).is_null() {
                return -(1 as i32);
            }
            return 0;
        } else {
            if (unsafe { strcmp(pane, b"{down-of}\0" as *const u8 as *const i8) }) == 0 {
                (unsafe { (*fs).wp = window_pane_find_down((*(*fs).w).active) });
                if (unsafe { (*fs).wp }).is_null() {
                    return -(1 as i32);
                }
                return 0;
            } else {
                if (unsafe { strcmp(pane, b"{left-of}\0" as *const u8 as *const i8) }) == 0 {
                    (unsafe { (*fs).wp = window_pane_find_left((*(*fs).w).active) });
                    if (unsafe { (*fs).wp }).is_null() {
                        return -(1 as i32);
                    }
                    return 0;
                } else {
                    if (unsafe { strcmp(pane, b"{right-of}\0" as *const u8 as *const i8) })
                        == 0
                    {
                        (unsafe { (*fs).wp = window_pane_find_right((*(*fs).w).active) });
                        if (unsafe { (*fs).wp }).is_null() {
                            return -(1 as i32);
                        }
                        return 0;
                    }
                }
            }
        }
    }
    if (unsafe { *pane.offset(0 as i32 as isize) }) as i32 == '+' as i32
        || (unsafe { *pane.offset(0 as i32 as isize) }) as i32 == '-' as i32
    {
        if (unsafe { *pane.offset(1 as i32 as isize) }) as i32 != '\0' as i32 {
            n = (unsafe {
                strtonum(
                    pane.offset(1 as i32 as isize), 1 as i64, 2147483647 as i64,
                    std::ptr::null_mut::<*const i8>(),
                )
            }) as u_int;
        } else {
            n = 1 as u_int;
        }
        wp = unsafe { (*(*fs).w).active };
        if (unsafe { *pane.offset(0 as i32 as isize) }) as i32 == '+' as i32 {
            (unsafe { (*fs).wp = window_pane_next_by_number((*fs).w, wp, n) });
        } else {
            (unsafe { (*fs).wp = window_pane_previous_by_number((*fs).w, wp, n) });
        }
        if !(unsafe { (*fs).wp }).is_null() {
            return 0;
        }
    }
    idx =
        (unsafe { strtonum(pane, 0 as i64, 2147483647 as i64, &mut errstr) }) as i32;
    if errstr.is_null() {
        (unsafe { (*fs).wp = window_pane_at_index((*fs).w, idx as u_int) });
        if !(unsafe { (*fs).wp }).is_null() {
            return 0;
        }
    }
    (unsafe { (*fs).wp = window_find_string((*fs).w, pane) });
    if !(unsafe { (*fs).wp }).is_null() {
        return 0;
    }
    return -(1 as i32);
}
#[no_mangle]
pub extern "C" fn cmd_find_clear_state(mut fs: *mut cmd_find_state, mut flags: i32) {
    (unsafe {
        memset(
            fs as *mut (), 0,
            ::core::mem::size_of::<cmd_find_state>() as u64,
        )
    });
    (unsafe { (*fs).flags = flags });
    (unsafe { (*fs).idx = -(1 as i32) });
}
#[no_mangle]
pub extern "C" fn cmd_find_empty_state(mut fs: *mut cmd_find_state) -> i32 {
    if (unsafe { (*fs).s }).is_null()
        && (unsafe { (*fs).wl }).is_null()
        && (unsafe { (*fs).w }).is_null()
        && (unsafe { (*fs).wp }).is_null()
    {
        return 1;
    }
    return 0;
}
#[no_mangle]
pub extern "C" fn cmd_find_valid_state(mut fs: *mut cmd_find_state) -> i32 {
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    if (unsafe { (*fs).s }).is_null()
        || (unsafe { (*fs).wl }).is_null()
        || (unsafe { (*fs).w }).is_null()
        || (unsafe { (*fs).wp }).is_null()
    {
        return 0;
    }
    if (unsafe { session_alive((*fs).s) }) == 0 {
        return 0;
    }
    wl = unsafe { winlinks_RB_MINMAX(&mut (*(*fs).s).windows, -(1 as i32)) };
    while !wl.is_null() {
        if (unsafe { (*wl).window }) == (unsafe { (*fs).w }) && wl == (unsafe { (*fs).wl }) {
            break;
        }
        wl = unsafe { winlinks_RB_NEXT(wl) };
    }
    if wl.is_null() {
        return 0;
    }
    if (unsafe { (*fs).w }) != (unsafe { (*(*fs).wl).window }) {
        return 0;
    }
    return unsafe { window_has_pane((*fs).w, (*fs).wp) };
}
#[no_mangle]
pub extern "C" fn cmd_find_copy_state(mut dst: *mut cmd_find_state, mut src: *mut cmd_find_state) {
    (unsafe { (*dst).s = (*src).s });
    (unsafe { (*dst).wl = (*src).wl });
    (unsafe { (*dst).idx = (*src).idx });
    (unsafe { (*dst).w = (*src).w });
    (unsafe { (*dst).wp = (*src).wp });
}
extern "C" fn cmd_find_log_state(mut prefix: *const i8, mut fs: *mut cmd_find_state) {
    if !(unsafe { (*fs).s }).is_null() {
        (unsafe {
            log_debug(
                b"%s: s=$%u %s\0" as *const u8 as *const i8,
                prefix,
                (*(*fs).s).id,
                (*(*fs).s).name,
            )
        });
    } else {
        (unsafe { log_debug(b"%s: s=none\0" as *const u8 as *const i8, prefix) });
    }
    if !(unsafe { (*fs).wl }).is_null() {
        (unsafe {
            log_debug(
                b"%s: wl=%u %d w=@%u %s\0" as *const u8 as *const i8,
                prefix,
                (*(*fs).wl).idx,
                ((*(*fs).wl).window == (*fs).w) as i32,
                (*(*fs).w).id,
                (*(*fs).w).name,
            )
        });
    } else {
        (unsafe { log_debug(b"%s: wl=none\0" as *const u8 as *const i8, prefix) });
    }
    if !(unsafe { (*fs).wp }).is_null() {
        (unsafe {
            log_debug(
                b"%s: wp=%%%u\0" as *const u8 as *const i8,
                prefix,
                (*(*fs).wp).id,
            )
        });
    } else {
        (unsafe { log_debug(b"%s: wp=none\0" as *const u8 as *const i8, prefix) });
    }
    if (unsafe { (*fs).idx }) != -(1 as i32) {
        (unsafe { log_debug(b"%s: idx=%d\0" as *const u8 as *const i8, prefix, (*fs).idx) });
    } else {
        (unsafe { log_debug(b"%s: idx=none\0" as *const u8 as *const i8, prefix) });
    };
}
#[no_mangle]
pub extern "C" fn cmd_find_from_session(
    mut fs: *mut cmd_find_state,
    mut s: *mut session,
    mut flags: i32,
) {
    cmd_find_clear_state(fs, flags);
    (unsafe { (*fs).s = s });
    (unsafe { (*fs).wl = (*(*fs).s).curw });
    (unsafe { (*fs).w = (*(*fs).wl).window });
    (unsafe { (*fs).wp = (*(*fs).w).active });
    cmd_find_log_state(
        (*(unsafe { ::core::mem::transmute::<&[u8; 22], &[i8; 22]>(b"cmd_find_from_session\0") }))
            .as_ptr(),
        fs,
    );
}
#[no_mangle]
pub extern "C" fn cmd_find_from_winlink(
    mut fs: *mut cmd_find_state,
    mut wl: *mut winlink,
    mut flags: i32,
) {
    cmd_find_clear_state(fs, flags);
    (unsafe { (*fs).s = (*wl).session });
    (unsafe { (*fs).wl = wl });
    (unsafe { (*fs).w = (*wl).window });
    (unsafe { (*fs).wp = (*(*wl).window).active });
    cmd_find_log_state(
        (*(unsafe { ::core::mem::transmute::<&[u8; 22], &[i8; 22]>(b"cmd_find_from_winlink\0") }))
            .as_ptr(),
        fs,
    );
}
#[no_mangle]
pub extern "C" fn cmd_find_from_session_window(
    mut fs: *mut cmd_find_state,
    mut s: *mut session,
    mut w: *mut window,
    mut flags: i32,
) -> i32 {
    cmd_find_clear_state(fs, flags);
    (unsafe { (*fs).s = s });
    (unsafe { (*fs).w = w });
    if cmd_find_best_winlink_with_window(fs) != 0 {
        cmd_find_clear_state(fs, flags);
        return -(1 as i32);
    }
    (unsafe { (*fs).wp = (*(*fs).w).active });
    cmd_find_log_state(
        (*(unsafe {
            ::core::mem::transmute::<&[u8; 29], &[i8; 29]>(b"cmd_find_from_session_window\0")
        }))
        .as_ptr(),
        fs,
    );
    return 0;
}
#[no_mangle]
pub extern "C" fn cmd_find_from_window(
    mut fs: *mut cmd_find_state,
    mut w: *mut window,
    mut flags: i32,
) -> i32 {
    cmd_find_clear_state(fs, flags);
    (unsafe { (*fs).w = w });
    if cmd_find_best_session_with_window(fs) != 0 {
        cmd_find_clear_state(fs, flags);
        return -(1 as i32);
    }
    if cmd_find_best_winlink_with_window(fs) != 0 {
        cmd_find_clear_state(fs, flags);
        return -(1 as i32);
    }
    (unsafe { (*fs).wp = (*(*fs).w).active });
    cmd_find_log_state(
        (*(unsafe { ::core::mem::transmute::<&[u8; 21], &[i8; 21]>(b"cmd_find_from_window\0") }))
            .as_ptr(),
        fs,
    );
    return 0;
}
#[no_mangle]
pub extern "C" fn cmd_find_from_winlink_pane(
    mut fs: *mut cmd_find_state,
    mut wl: *mut winlink,
    mut wp: *mut window_pane,
    mut flags: i32,
) {
    cmd_find_clear_state(fs, flags);
    (unsafe { (*fs).s = (*wl).session });
    (unsafe { (*fs).wl = wl });
    (unsafe { (*fs).idx = (*(*fs).wl).idx });
    (unsafe { (*fs).w = (*(*fs).wl).window });
    (unsafe { (*fs).wp = wp });
    cmd_find_log_state(
        (*(unsafe {
            ::core::mem::transmute::<&[u8; 27], &[i8; 27]>(b"cmd_find_from_winlink_pane\0")
        }))
        .as_ptr(),
        fs,
    );
}
#[no_mangle]
pub extern "C" fn cmd_find_from_pane(
    mut fs: *mut cmd_find_state,
    mut wp: *mut window_pane,
    mut flags: i32,
) -> i32 {
    if cmd_find_from_window(fs, unsafe { (*wp).window }, flags) != 0 {
        return -(1 as i32);
    }
    (unsafe { (*fs).wp = wp });
    cmd_find_log_state(
        (*(unsafe { ::core::mem::transmute::<&[u8; 19], &[i8; 19]>(b"cmd_find_from_pane\0") }))
            .as_ptr(),
        fs,
    );
    return 0;
}
#[no_mangle]
pub extern "C" fn cmd_find_from_nothing(mut fs: *mut cmd_find_state, mut flags: i32) -> i32 {
    cmd_find_clear_state(fs, flags);
    (unsafe {
        (*fs).s = cmd_find_best_session(
            std::ptr::null_mut::<*mut session>(), 0 as u_int,
            flags,
        )
    });
    if (unsafe { (*fs).s }).is_null() {
        cmd_find_clear_state(fs, flags);
        return -(1 as i32);
    }
    (unsafe { (*fs).wl = (*(*fs).s).curw });
    (unsafe { (*fs).idx = (*(*fs).wl).idx });
    (unsafe { (*fs).w = (*(*fs).wl).window });
    (unsafe { (*fs).wp = (*(*fs).w).active });
    cmd_find_log_state(
        (*(unsafe { ::core::mem::transmute::<&[u8; 22], &[i8; 22]>(b"cmd_find_from_nothing\0") }))
            .as_ptr(),
        fs,
    );
    return 0;
}
#[no_mangle]
pub extern "C" fn cmd_find_from_mouse(
    mut fs: *mut cmd_find_state,
    mut m: *mut mouse_event,
    mut flags: i32,
) -> i32 {
    cmd_find_clear_state(fs, flags);
    if (unsafe { (*m).valid }) == 0 {
        return -(1 as i32);
    }
    (unsafe { (*fs).wp = cmd_mouse_pane(m, &mut (*fs).s, &mut (*fs).wl) });
    if (unsafe { (*fs).wp }).is_null() {
        cmd_find_clear_state(fs, flags);
        return -(1 as i32);
    }
    (unsafe { (*fs).w = (*(*fs).wl).window });
    cmd_find_log_state(
        (*(unsafe { ::core::mem::transmute::<&[u8; 20], &[i8; 20]>(b"cmd_find_from_mouse\0") }))
            .as_ptr(),
        fs,
    );
    return 0;
}
#[no_mangle]
pub extern "C" fn cmd_find_from_client(
    mut fs: *mut cmd_find_state,
    mut c: *mut client,
    mut flags: i32,
) -> i32 {
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    if c.is_null() {
        return cmd_find_from_nothing(fs, flags);
    }
    if !(unsafe { (*c).session }).is_null() {
        cmd_find_clear_state(fs, flags);
        (unsafe { (*fs).wp = server_client_get_pane(c) });
        if (unsafe { (*fs).wp }).is_null() {
            cmd_find_from_session(fs, unsafe { (*c).session }, flags);
            return 0;
        }
        (unsafe { (*fs).s = (*c).session });
        (unsafe { (*fs).wl = (*(*fs).s).curw });
        (unsafe { (*fs).w = (*(*fs).wl).window });
        cmd_find_log_state(
            (*(unsafe {
                ::core::mem::transmute::<&[u8; 21], &[i8; 21]>(b"cmd_find_from_client\0")
            }))
            .as_ptr(),
            fs,
        );
        return 0;
    }
    cmd_find_clear_state(fs, flags);
    wp = cmd_find_inside_pane(c);
    if !wp.is_null() {
        (unsafe { (*fs).w = (*wp).window });
        if cmd_find_best_session_with_window(fs) == 0 {
            (unsafe { (*fs).wl = (*(*fs).s).curw });
            (unsafe { (*fs).w = (*(*fs).wl).window });
            (unsafe { (*fs).wp = (*(*fs).w).active });
            cmd_find_log_state(
                (*(unsafe {
                    ::core::mem::transmute::<&[u8; 21], &[i8; 21]>(b"cmd_find_from_client\0")
                }))
                .as_ptr(),
                fs,
            );
            return 0;
        }
    }
    return cmd_find_from_nothing(fs, flags);
}
#[no_mangle]
pub extern "C" fn cmd_find_target(
    mut fs: *mut cmd_find_state,
    mut item: *mut cmdq_item,
    mut target: *const i8,
    mut type_0: cmd_find_type,
    mut flags: i32,
) -> i32 {
    let mut current_block: u64;
    let mut m: *mut mouse_event = std::ptr::null_mut::<mouse_event>();
    let mut current: cmd_find_state = cmd_find_state {
        flags: 0,
        current: std::ptr::null::<cmd_find_state>() as *mut cmd_find_state,
        s: std::ptr::null::<session>() as *mut session,
        wl: std::ptr::null::<winlink>() as *mut winlink,
        w: std::ptr::null::<window>() as *mut window,
        wp: std::ptr::null::<window_pane>() as *mut window_pane,
        idx: 0,
    };
    let mut colon: *mut i8 = std::ptr::null_mut::<i8>();
    let mut period: *mut i8 = std::ptr::null_mut::<i8>();
    let mut copy: *mut i8 = std::ptr::null_mut::<i8>();
    let mut tmp: [i8; 256] = [0; 256];
    let mut session: *const i8 = std::ptr::null::<i8>();
    let mut window: *const i8 = std::ptr::null::<i8>();
    let mut pane: *const i8 = std::ptr::null::<i8>();
    let mut s: *const i8 = std::ptr::null::<i8>();
    let mut window_only: i32 = 0;
    let mut pane_only: i32 = 0;
    if flags & 0x40 as i32 != 0 {
        flags |= 0x2 as i32;
    }
    if type_0 as u32 == CMD_FIND_PANE as i32 as u32 {
        s = b"pane\0" as *const u8 as *const i8;
    } else if type_0 as u32 == CMD_FIND_WINDOW as i32 as u32 {
        s = b"window\0" as *const u8 as *const i8;
    } else if type_0 as u32 == CMD_FIND_SESSION as i32 as u32 {
        s = b"session\0" as *const u8 as *const i8;
    } else {
        s = b"unknown\0" as *const u8 as *const i8;
    }
    (unsafe { *tmp.as_mut_ptr() = '\0' as i32 as i8 });
    if flags & 0x1 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"PREFER_UNATTACHED,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if flags & 0x2 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"QUIET,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if flags & 0x4 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"WINDOW_INDEX,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if flags & 0x8 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"DEFAULT_MARKED,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if flags & 0x10 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"EXACT_SESSION,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if flags & 0x20 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"EXACT_WINDOW,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if flags & 0x40 as i32 != 0 {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"CANFAIL,\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    if (unsafe { *tmp.as_mut_ptr() }) as i32 != '\0' as i32 {
        tmp[(unsafe { strlen(tmp.as_mut_ptr()) }).wrapping_sub(1 as i32 as u64) as usize] =
            '\0' as i32 as i8;
    } else {
        (unsafe {
            strlcat(
                tmp.as_mut_ptr(),
                b"NONE\0" as *const u8 as *const i8,
                ::core::mem::size_of::<[i8; 256]>() as u64,
            )
        });
    }
    (unsafe {
        log_debug(
            b"%s: target %s, type %s, item %p, flags %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0")).as_ptr(),
            if target.is_null() {
                b"none\0" as *const u8 as *const i8
            } else {
                target
            },
            s,
            item,
            tmp.as_mut_ptr(),
        )
    });
    cmd_find_clear_state(fs, flags);
    if (unsafe { server_check_marked() }) != 0 && flags & 0x8 as i32 != 0 {
        (unsafe { (*fs).current = &mut marked_pane });
        (unsafe {
            log_debug(
                b"%s: current is marked pane\0" as *const u8 as *const i8,
                (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0")).as_ptr(),
            )
        });
        current_block = 2604890879466389055;
    } else if cmd_find_valid_state(unsafe { cmdq_get_current(item) }) != 0 {
        (unsafe { (*fs).current = cmdq_get_current(item) });
        (unsafe {
            log_debug(
                b"%s: current is from queue\0" as *const u8 as *const i8,
                (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0")).as_ptr(),
            )
        });
        current_block = 2604890879466389055;
    } else if cmd_find_from_client(&mut current, unsafe { cmdq_get_client(item) }, flags)
        == 0
    {
        (unsafe { (*fs).current = &mut current });
        (unsafe {
            log_debug(
                b"%s: current is from client\0" as *const u8 as *const i8,
                (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0")).as_ptr(),
            )
        });
        current_block = 2604890879466389055;
    } else {
        if !flags & 0x2 as i32 != 0 {
            (unsafe { cmdq_error(item, b"no current target\0" as *const u8 as *const i8) });
        }
        current_block = 5542189172462888401;
    }
    match current_block {
        2604890879466389055 => {
            if cmd_find_valid_state(unsafe { (*fs).current }) == 0 {
                (unsafe { fatalx(b"invalid current find state\0" as *const u8 as *const i8) });
            }
            if target.is_null() || (unsafe { *target }) as i32 == '\0' as i32 {
                current_block = 16180051146927387409;
            } else if (unsafe { strcmp(target, b"=\0" as *const u8 as *const i8) }) == 0
                || (unsafe { strcmp(target, b"{mouse}\0" as *const u8 as *const i8) }) == 0
            {
                m = unsafe {
                    &mut (*(cmdq_get_event
                        as unsafe extern "C" fn(*mut cmdq_item) -> *mut key_event)(
                        item
                    ))
                    .m
                };
                let mut current_block_51: u64;
                match type_0 as u32 {
                    0 => {
                        (unsafe { (*fs).wp = cmd_mouse_pane(m, &mut (*fs).s, &mut (*fs).wl) });
                        if !(unsafe { (*fs).wp }).is_null() {
                            (unsafe { (*fs).w = (*(*fs).wl).window });
                            current_block_51 = 3689906465960840878;
                        } else {
                            current_block_51 = 4126416354161996257;
                        }
                    }
                    1 | 2 => {
                        current_block_51 = 4126416354161996257;
                    }
                    _ => {
                        current_block_51 = 3689906465960840878;
                    }
                }
                match current_block_51 {
                    4126416354161996257 => {
                        (unsafe { (*fs).wl = cmd_mouse_window(m, &mut (*fs).s) });
                        if (unsafe { (*fs).wl }).is_null() && !(unsafe { (*fs).s }).is_null() {
                            (unsafe { (*fs).wl = (*(*fs).s).curw });
                        }
                        if !(unsafe { (*fs).wl }).is_null() {
                            (unsafe { (*fs).w = (*(*fs).wl).window });
                            (unsafe { (*fs).wp = (*(*fs).w).active });
                        }
                    }
                    _ => {}
                }
                if (unsafe { (*fs).wp }).is_null() {
                    if !flags & 0x2 as i32 != 0 {
                        (unsafe {
                            cmdq_error(item, b"no mouse target\0" as *const u8 as *const i8)
                        });
                    }
                    current_block = 5542189172462888401;
                } else {
                    current_block = 345822284797575840;
                }
            } else if (unsafe { strcmp(target, b"~\0" as *const u8 as *const i8) }) == 0
                || (unsafe { strcmp(target, b"{marked}\0" as *const u8 as *const i8) }) == 0
            {
                if (unsafe { server_check_marked() }) == 0 {
                    if !flags & 0x2 as i32 != 0 {
                        (unsafe {
                            cmdq_error(item, b"no marked target\0" as *const u8 as *const i8)
                        });
                    }
                    current_block = 5542189172462888401;
                } else {
                    cmd_find_copy_state(fs, unsafe { &mut marked_pane });
                    current_block = 345822284797575840;
                }
            } else {
                copy = unsafe { xstrdup(target) };
                colon = unsafe { strchr(copy, ':' as i32) };
                if !colon.is_null() {
                    let fresh2 = colon;
                    colon = unsafe { colon.offset(1) };
                    (unsafe { *fresh2 = '\0' as i32 as i8 });
                }
                if colon.is_null() {
                    period = unsafe { strchr(copy, '.' as i32) };
                } else {
                    period = unsafe { strchr(colon, '.' as i32) };
                }
                if !period.is_null() {
                    let fresh3 = period;
                    period = unsafe { period.offset(1) };
                    (unsafe { *fresh3 = '\0' as i32 as i8 });
                }
                pane = std::ptr::null::<i8>();
                window = pane;
                session = window;
                if !colon.is_null() && !period.is_null() {
                    session = copy;
                    window = colon;
                    window_only = 1;
                    pane = period;
                    pane_only = 1;
                } else if !colon.is_null() && period.is_null() {
                    session = copy;
                    window = colon;
                    window_only = 1;
                } else if colon.is_null() && !period.is_null() {
                    window = copy;
                    pane = period;
                    pane_only = 1;
                } else if (unsafe { *copy }) as i32 == '$' as i32 {
                    session = copy;
                } else if (unsafe { *copy }) as i32 == '@' as i32 {
                    window = copy;
                } else if (unsafe { *copy }) as i32 == '%' as i32 {
                    pane = copy;
                } else {
                    match type_0 as u32 {
                        2 => {
                            session = copy;
                        }
                        1 => {
                            window = copy;
                        }
                        0 => {
                            pane = copy;
                        }
                        _ => {}
                    }
                }
                if !session.is_null() && (unsafe { *session }) as i32 == '=' as i32 {
                    session = unsafe { session.offset(1) };
                    (unsafe { (*fs).flags |= 0x10 as i32 });
                }
                if !window.is_null() && (unsafe { *window }) as i32 == '=' as i32 {
                    window = unsafe { window.offset(1) };
                    (unsafe { (*fs).flags |= 0x20 as i32 });
                }
                if !session.is_null() && (unsafe { *session }) as i32 == '\0' as i32 {
                    session = std::ptr::null::<i8>();
                }
                if !window.is_null() && (unsafe { *window }) as i32 == '\0' as i32 {
                    window = std::ptr::null::<i8>();
                }
                if !pane.is_null() && (unsafe { *pane }) as i32 == '\0' as i32 {
                    pane = std::ptr::null::<i8>();
                }
                if !session.is_null() {
                    session =
                        cmd_find_map_table(unsafe { cmd_find_session_table.as_mut_ptr() }, session);
                }
                if !window.is_null() {
                    window =
                        cmd_find_map_table(unsafe { cmd_find_window_table.as_mut_ptr() }, window);
                }
                if !pane.is_null() {
                    pane = cmd_find_map_table(unsafe { cmd_find_pane_table.as_mut_ptr() }, pane);
                }
                if !session.is_null() || !window.is_null() || !pane.is_null() {
                    (unsafe {
                        log_debug(
                            b"%s: target %s is %s%s%s%s%s%s\0" as *const u8 as *const i8,
                            (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0"))
                                .as_ptr(),
                            target,
                            if session.is_null() {
                                b"\0" as *const u8 as *const i8
                            } else {
                                b"session \0" as *const u8 as *const i8
                            },
                            if session.is_null() {
                                b"\0" as *const u8 as *const i8
                            } else {
                                session
                            },
                            if window.is_null() {
                                b"\0" as *const u8 as *const i8
                            } else {
                                b"window \0" as *const u8 as *const i8
                            },
                            if window.is_null() {
                                b"\0" as *const u8 as *const i8
                            } else {
                                window
                            },
                            if pane.is_null() {
                                b"\0" as *const u8 as *const i8
                            } else {
                                b"pane \0" as *const u8 as *const i8
                            },
                            if pane.is_null() {
                                b"\0" as *const u8 as *const i8
                            } else {
                                pane
                            },
                        )
                    });
                }
                if !pane.is_null() && flags & 0x4 as i32 != 0 {
                    if !flags & 0x2 as i32 != 0 {
                        (unsafe {
                            cmdq_error(item, b"can't specify pane here\0" as *const u8 as *const i8)
                        });
                    }
                    current_block = 5542189172462888401;
                } else {
                    if !session.is_null() {
                        if cmd_find_get_session(fs, session) != 0 {
                            if !flags & 0x2 as i32 != 0 {
                                (unsafe {
                                    cmdq_error(
                                        item,
                                        b"can't find session: %s\0" as *const u8 as *const i8,
                                        session,
                                    )
                                });
                            }
                            current_block = 5542189172462888401;
                        } else if window.is_null() && pane.is_null() {
                            (unsafe { (*fs).wl = (*(*fs).s).curw });
                            (unsafe { (*fs).idx = -(1 as i32) });
                            (unsafe { (*fs).w = (*(*fs).wl).window });
                            (unsafe { (*fs).wp = (*(*fs).w).active });
                            current_block = 345822284797575840;
                        } else if !window.is_null() && pane.is_null() {
                            if cmd_find_get_window_with_session(fs, window) != 0 {
                                current_block = 11568790450509590091;
                            } else {
                                if !(unsafe { (*fs).wl }).is_null() {
                                    (unsafe { (*fs).wp = (*(*(*fs).wl).window).active });
                                }
                                current_block = 345822284797575840;
                            }
                        } else if window.is_null() && !pane.is_null() {
                            if cmd_find_get_pane_with_session(fs, pane) != 0 {
                                current_block = 15866988114757184400;
                            } else {
                                current_block = 345822284797575840;
                            }
                        } else if cmd_find_get_window_with_session(fs, window) != 0 {
                            current_block = 11568790450509590091;
                        } else if cmd_find_get_pane_with_window(fs, pane) != 0 {
                            current_block = 15866988114757184400;
                        } else {
                            current_block = 345822284797575840;
                        }
                    } else if !window.is_null() && !pane.is_null() {
                        if cmd_find_get_window(fs, window, window_only) != 0 {
                            current_block = 11568790450509590091;
                        } else if cmd_find_get_pane_with_window(fs, pane) != 0 {
                            current_block = 15866988114757184400;
                        } else {
                            current_block = 345822284797575840;
                        }
                    } else if !window.is_null() && pane.is_null() {
                        if cmd_find_get_window(fs, window, window_only) != 0 {
                            current_block = 11568790450509590091;
                        } else {
                            if !(unsafe { (*fs).wl }).is_null() {
                                (unsafe { (*fs).wp = (*(*(*fs).wl).window).active });
                            }
                            current_block = 345822284797575840;
                        }
                    } else if window.is_null() && !pane.is_null() {
                        if cmd_find_get_pane(fs, pane, pane_only) != 0 {
                            current_block = 15866988114757184400;
                        } else {
                            current_block = 345822284797575840;
                        }
                    } else {
                        current_block = 16180051146927387409;
                    }
                    match current_block {
                        5542189172462888401 => {}
                        345822284797575840 => {}
                        16180051146927387409 => {}
                        _ => {
                            match current_block {
                                11568790450509590091 => {
                                    if !flags & 0x2 as i32 != 0 {
                                        (unsafe {
                                            cmdq_error(
                                                item,
                                                b"can't find window: %s\0" as *const u8
                                                    as *const i8,
                                                window,
                                            )
                                        });
                                    }
                                }
                                _ => {
                                    if !flags & 0x2 as i32 != 0 {
                                        (unsafe {
                                            cmdq_error(
                                                item,
                                                b"can't find pane: %s\0" as *const u8 as *const i8,
                                                pane,
                                            )
                                        });
                                    }
                                }
                            }
                            current_block = 5542189172462888401;
                        }
                    }
                }
            }
            match current_block {
                5542189172462888401 => {}
                _ => {
                    match current_block {
                        16180051146927387409 => {
                            cmd_find_copy_state(fs, unsafe { (*fs).current });
                            if flags & 0x4 as i32 != 0 {
                                (unsafe { (*fs).idx = -(1 as i32) });
                            }
                        }
                        _ => {}
                    }
                    (unsafe { (*fs).current = std::ptr::null_mut::<cmd_find_state>() });
                    cmd_find_log_state(
                        (*(unsafe {
                            ::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0")
                        }))
                        .as_ptr(),
                        fs,
                    );
                    (unsafe { free(copy as *mut ()) });
                    return 0;
                }
            }
        }
        _ => {}
    }
    (unsafe { (*fs).current = std::ptr::null_mut::<cmd_find_state>() });
    (unsafe {
        log_debug(
            b"%s: error\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_target\0")).as_ptr(),
        )
    });
    (unsafe { free(copy as *mut ()) });
    if flags & 0x40 as i32 != 0 {
        return 0;
    }
    return -(1 as i32);
}
extern "C" fn cmd_find_current_client(mut item: *mut cmdq_item, mut quiet: i32) -> *mut client {
    let mut c: *mut client = std::ptr::null_mut::<client>();
    let mut found: *mut client = std::ptr::null_mut::<client>();
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    let mut fs: cmd_find_state = cmd_find_state {
        flags: 0,
        current: std::ptr::null::<cmd_find_state>() as *mut cmd_find_state,
        s: std::ptr::null::<session>() as *mut session,
        wl: std::ptr::null::<winlink>() as *mut winlink,
        w: std::ptr::null::<window>() as *mut window,
        wp: std::ptr::null::<window_pane>() as *mut window_pane,
        idx: 0,
    };
    if !item.is_null() {
        c = unsafe { cmdq_get_client(item) };
    }
    if !c.is_null() && !(unsafe { (*c).session }).is_null() {
        return c;
    }
    found = std::ptr::null_mut::<client>();
    if !c.is_null() && {
        wp = cmd_find_inside_pane(c);
        !wp.is_null()
    } {
        cmd_find_clear_state(&mut fs, 0x2 as i32);
        fs.w = unsafe { (*wp).window };
        if cmd_find_best_session_with_window(&mut fs) == 0 {
            found = cmd_find_best_client(fs.s);
        }
    } else {
        s = cmd_find_best_session(
            std::ptr::null_mut::<*mut session>(), 0 as u_int,
            0x2 as i32,
        );
        if !s.is_null() {
            found = cmd_find_best_client(s);
        }
    }
    if found.is_null() && !item.is_null() && quiet == 0 {
        (unsafe { cmdq_error(item, b"no current client\0" as *const u8 as *const i8) });
    }
    (unsafe {
        log_debug(
            b"%s: no target, return %p\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 24], &[i8; 24]>(b"cmd_find_current_client\0"))
                .as_ptr(),
            found,
        )
    });
    return found;
}
#[no_mangle]
pub extern "C" fn cmd_find_client(
    mut item: *mut cmdq_item,
    mut target: *const i8,
    mut quiet: i32,
) -> *mut client {
    let mut c: *mut client = std::ptr::null_mut::<client>();
    let mut copy: *mut i8 = std::ptr::null_mut::<i8>();
    let mut size: size_t = 0;
    if target.is_null() {
        return cmd_find_current_client(item, quiet);
    }
    copy = unsafe { xstrdup(target) };
    size = unsafe { strlen(copy) };
    if size != 0 as u64
        && (unsafe { *copy.offset(size.wrapping_sub(1 as i32 as u64) as isize) }) as i32
            == ':' as i32
    {
        (unsafe { *copy.offset(size.wrapping_sub(1 as i32 as u64) as isize) = '\0' as i32 as i8 });
    }
    c = unsafe { clients.tqh_first };
    while !c.is_null() {
        if !(unsafe { (*c).session }).is_null() {
            if (unsafe { strcmp(copy, (*c).name) }) == 0 {
                break;
            }
            if (unsafe { *(*c).ttyname }) as i32 != '\0' as i32 {
                if (unsafe { strcmp(copy, (*c).ttyname) }) == 0 {
                    break;
                }
                if (unsafe {
                    strncmp(
                        (*c).ttyname,
                        b"/dev/\0" as *const u8 as *const i8,
                        (::core::mem::size_of::<[i8; 6]>() as u64).wrapping_sub(1 as i32 as u64),
                    )
                }) == 0
                {
                    if (unsafe {
                        strcmp(
                            copy,
                            ((*c).ttyname)
                                .offset(::core::mem::size_of::<[i8; 6]>() as u64 as isize)
                                .offset(-(1 as i32 as isize)),
                        )
                    }) == 0
                    {
                        break;
                    }
                }
            }
        }
        c = unsafe { (*c).entry.tqe_next };
    }
    if c.is_null() && quiet == 0 {
        (unsafe {
            cmdq_error(
                item,
                b"can't find client: %s\0" as *const u8 as *const i8,
                copy,
            )
        });
    }
    (unsafe { free(copy as *mut ()) });
    (unsafe {
        log_debug(
            b"%s: target %s, return %p\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_find_client\0")).as_ptr(),
            target,
            c,
        )
    });
    return c;
}
